/**
 * 项目服务
 */
const BaseProjectService = require('./base_project_service.js');
const ProjectModel = require('../config/models_config').project_model;
const cloudUtil = require('../../../framework/cloud/cloud_util.js');
const timeUtil = require('../../../framework/helpers/time_util.js');

class ProjectService extends BaseProjectService {

	constructor() {
		super();
		this._model = new ProjectModel();
	}

	/**
	 * 创建项目
	 */
	async createProject(projectData) {
		try {
			console.log('[ProjectService] 开始创建项目，数据:', projectData);
			
			// 添加时间戳
			projectData.createTime = this._timestamp;
			projectData.updateTime = this._timestamp;
			
			// 添加创建者信息
			if (!projectData.createBy) {
				projectData.createBy = this._userId;
			}
			
			console.log('[ProjectService] 准备插入数据库的项目数据:', projectData);
			
			// 插入数据
			const result = await ProjectModel.insertProject(projectData);
			
			console.log('[ProjectService] 插入结果:', result);
			
			if (result && result.insertedId) {
				// 查询刚刚创建的项目的完整信息
				const projectId = result.insertedId.toString();
				console.log('[ProjectService] 项目创建成功，ID:', projectId);
				
				try {
					// 获取完整的项目信息
					const project = await ProjectModel.getProjectDetail(projectId);
					
					// 确保项目有_id字段
					if (project && !project._id) {
						project._id = projectId;
					}
					
					console.log('[ProjectService] 新创建的项目完整信息:', project);
					
					// 返回包含_id的项目ID
					return projectId;
				} catch (err) {
					console.error('[ProjectService] 获取新创建项目详情失败:', err);
					return projectId; // 即使获取详情失败，也返回ID
				}
			} else {
				console.error('[ProjectService] 项目创建失败，无法获取ID');
				return null;
			}
		} catch (err) {
			console.error('[ProjectService] 创建项目错误:', err);
			throw err;
		}
	}

	/**
	 * 更新项目
	 */
	async updateProject(id, data) {
		// 检查项目是否存在
		let project = await ProjectModel.getProject({
			_id: id
		});
		if (!project) throw new Error('项目不存在');

		// 设置必要的字段
		data.updateTime = this._timestamp;
		data._pid = 'oa'; // 项目ID
		
		console.log('[updateProject] 处理后的项目数据:', JSON.stringify(data));

		// 使用静态方法而不是实例方法
		return await ProjectModel.updateProject(id, data);
	}

	/**
	 * 删除项目
	 */
	async deleteProject(id) {
		// 检查项目是否存在
		let project = await this._model.getProject({
			_id: id
		});
		if (!project) throw new Error('项目不存在');

		return await this._model.deleteProject({
			_id: id
		});
	}

	/**
	 * 获取项目列表
	 */
	async getProjectList({
		search, // 搜索条件
		sortType, // 排序
		sortVal, // 排序值
		orderBy, // 排序字段
		whereEx, // 查询条件 
		page,
		size,
		oldTotal = 0,
		isTotal = true,
		oldList = [],
		disableFormat = false, // 不格式化返回值
	}) {
		let result = await ProjectModel.getProjectList({
			search,
			sortType,
			sortVal,
			orderBy,
			whereEx,
			page,
			size,
			oldTotal,
			isTotal,
			oldList,
			disableFormat
		});

		// 格式化日期
		if (!disableFormat) {
			result.list.forEach(item => {
				if (item.startDate) {
					item.startDate = timeUtil.timestamp2Time(item.startDate, 'Y-M-D');
				}
				if (item.deadline) {
					item.deadline = timeUtil.timestamp2Time(item.deadline, 'Y-M-D');
				}
				
				// 状态转换
				switch (item.status) {
					case 'planning':
						item.statusDesc = '计划中';
						break;
					case 'ongoing':
						item.statusDesc = '进行中';
						break;
					case 'completed':
						item.statusDesc = '已完成';
						break;
					case 'suspended':
						item.statusDesc = '已暂停';
						break;
					default:
						item.statusDesc = '其他';
				}

				// 优先级转换
				switch (item.priority) {
					case 'low':
						item.priorityDesc = '低';
						break;
					case 'normal':
						item.priorityDesc = '中';
						break;
					case 'high':
						item.priorityDesc = '高';
						break;
					case 'urgent':
						item.priorityDesc = '紧急';
						break;
					default:
						item.priorityDesc = '其他';
				}
			});
		}

		return result;
	}

	/**
	 * 获取项目详情
	 */
	async getProjectDetail(id) {
		let result = await ProjectModel.getProjectDetail(id);
		if (result) {
			// 格式化日期
			if (result.startDate)
				result.startDate = timeUtil.timestamp2Time(result.startDate, 'Y-M-D');
			if (result.deadline)
				result.deadline = timeUtil.timestamp2Time(result.deadline, 'Y-M-D');
			
			// 状态转换
			switch (result.status) {
				case 'planning':
					result.statusDesc = '计划中';
					break;
				case 'ongoing':
					result.statusDesc = '进行中';
					break;
				case 'completed':
					result.statusDesc = '已完成';
					break;
				case 'suspended':
					result.statusDesc = '已暂停';
					break;
				default:
					result.statusDesc = '其他';
			}

			// 优先级转换
			switch (result.priority) {
				case 'low':
					result.priorityDesc = '低';
					break;
				case 'normal':
					result.priorityDesc = '中';
					break;
				case 'high':
					result.priorityDesc = '高';
					break;
				case 'urgent':
					result.priorityDesc = '紧急';
					break;
				default:
					result.priorityDesc = '其他';
			}
		}
		return result;
	}

	// 插入项目
	async insertProject(data) {
		console.log('[insertProject] 开始插入项目数据:', JSON.stringify(data));
		// 设置必要的字段
		data.USER_ID = this._userId;
		
		// 设置项目ID (防止脏数据:NO_ID错误)
		data._pid = 'oa'; // 项目ID
		
		// 添加项目编号
		data.projectNo = 'PRJ' + timeUtil.time('YMDhms');
		
		console.log('[insertProject] 处理后的项目数据:', JSON.stringify(data));
		const id = await ProjectModel.insertProject(data);
		console.log('[insertProject] 项目插入成功，ID:', id);
		return id;
	}

	// 更新项目
	async updateProject(id, data) {
		console.log('[updateProject] 开始更新项目数据，ID:', id, '数据:', JSON.stringify(data));
		
		// 设置项目ID (防止脏数据:NO_ID错误)
		data._pid = 'oa'; // 项目ID
		
		const result = await ProjectModel.updateProject(id, data);
		console.log('[updateProject] 项目更新结果:', result);
		return result;
	}

}

module.exports = ProjectService; 